Method and system for real-time resource consumption control in a distributed computing environment

ABSTRACT

The invention refers to a system for real-time resource consumption control in a distributed environment and a corresponding method, the system comprising: a multitude of server instances (Sx) having access to shared resources, whereby each request for a shared resource issued by a client application (CA) is handled by one of the server instances (Sx); a global resource consumption counter (G), representing the overall resource consumption of the multitude of server instances (Sx) at a given time; and a multitude of proxy servers (Lx), each proxy server comprising—a receiver module (R) for receiving resource consumption requests issued from a client application (CA), a resource consumption decision module (Dm) for accepting or rejecting a resource consumption request, a queue (Q) for collecting resource consumption requests that have been locally accepted by the respective proxy server (Lx), a local resource consumption counter (L), representing the global resource consumption as seen by the respective proxy server (Lx), said local resource consumption counter (L) being updated every time a resource consumption request is accepted by the decision module (Dm), the updated value being provided in turn as an input to the decision module (Dm), and a synchronization module (S) for synchronizing the global resource consumption counter (G) by interfacing with all other server instances (Sx).

CROSS REFERENCE TO RELATED APPLICATIONS

This application is the United States national phase under Section 35 U.S.C. Section 371 of International Application No. PCT/EP2015/002038, which was filed on Oct. 15, 2015 and claims priority to DE 10 2014 016 648.1, filed on Nov. 11, 2014.

BACKGROUND OF THE INVENTION Field of the Invention

The present invention relates to a method for real-time resource consumption control in a distributed computing environment. Furthermore, the present invention relates to a computer program product for executing this method, a computer readable data carrier with the computer program product stored thereon, and a system being developed to carry out the aforementioned method.

Background of the Related Art

Distributed computing environments are typically made up of several systems and resources and consolidate applications for carrying out a specific function across different locations. One example of a distributed computing environment is a SaaS (Software as a Service) environment (being considered as a part of cloud computing), where users subscribe to paid services by a service provider. The service provider monitors the consumption of resources by the users and enforces a limit to the resources users can consume according to what each user has paid for.

An example would be a system offering telephony services, where the users are charged on a monthly basis for the total duration (e.g., minutes) of outgoing calls. A more relevant example is where users prepay for a certain amount of outgoing call duration and the telephony service provider enforces this time limit by monitoring whether a user trying to place a call has already reached the prepaid limit.

In a collaborative SaaS environment the services might be offered to user groups rather than individual users, and the corresponding resources (e.g., outgoing call duration for the example above) can be consumed by any user in the group.

An example would be a collaborative application such as a file sharing service, where users in a group can exchange files by uploading them to a repository which is accessible by all the users in the group. The consumable resource in this example would be the amount of storage space allocated to the group. All users in a group can upload files to the repository and therefore consume a portion of the shared storage space. The service provider has to monitor the used storage space in the group and enforce that no user can upload more files than the available storage space in the group.

In a large SaaS environment, user requests are distributed to a multitude of server instances in a manner where different users in a group may be served by different instances of the server which provides a given service. Such an environment is illustrated in FIG. 1, wherein S_(x), i.e., (S₁-S_(n)) represents a multitude of server instances providing a certain service/feature which users in a group are paying for. Consumers, i.e., members of the group are accessing this cloud service, resulting in different users in a group being served by different instances of the server which provides the given service. The servers S_(x) are competing to consume a shared resource, thus causing delay in the decision process. Optionally, a load balancer LB may be used when consumers are accessing the service. A load balancer is a device that acts as a reverse proxy and distributes network or application traffic across a number of server instances. Load balancers are used to increase capacity (concurrent users) and reliability of applications.

It is, however, clear for the skilled worker that the present invention is not restricted to SaaS applications but can be used in other distributed computing environments as well.

When considering the file sharing service described in the example above, where different servers receive file upload requests by the users of a group, the enforcement of the storage space limit allocated to the group requires the consistent update of the group's used storage counter across all server instances by the service provider.

In another example, real time communication (RTC) services such as voice/video and web collaboration are offered to groups of users, and are charged by the service provider based on the total monthly duration of RTC sessions within the group, with a limit on the maximum duration per month. The consumption of this resource changes at such a rate that maintaining a consistent count across a large number of server instances would introduce a delay beyond what is considered acceptable for a real time voice/video service.

U.S. Pat. No. 5,579,222 discloses a distributed license administration system using a local policy server to communicate with a license server and control execution of computer programs. One computer, acting as a license server, identifies the nodes currently using the licensed software, handles the license conditions and checks whether or not these conditions are still met upon adding a new node. Each node maintains a policy server database, which specifies the license conditions for this node. A policy server daemon communicates with the license server, interfaces with the database and decides whether to grant or deny access to the licensed software.

In U.S. Pat. No. 7,849,019, floating licenses are managed by a central license server. This server assigns a number of licenses to secondary license managers, which in turn grant licenses to clients as requested. Each secondary server counts the licenses granted and released during a period of time and sends the values to the central license server to synchronize this server. The central server adjusts the number of licenses available at the secondary servers. The method allows to temporarily exceed the total number of available licenses.

The cited state of the art solutions show the problems that they either do not consider the lack of real-time responsiveness when a large amount of users compete for resources provided by a multitude of server instances or do need excessive synchronization between instances.

BRIEF SUMMARY OF THE INVENTION

It would be helpful to provide a method and a system for real-time resource consumption control in a distributed computing environment without excessive synchronization between instances.

The solution to the problem provides a method for real-time resource consumption control in a distributed computing environment, wherein this environment comprises a multitude of server instances having access to shared resources, whereby each request for a shared resource issued by a client application is handled by one of the server instances; a global resource consumption counter representing the overall resource consumption of the multitude of server instances at a given time; and a multitude of proxy servers. Each proxy server comprises a receiver module for receiving resource consumption requests issued from a client application, a resource consumption decision module for accepting or rejecting a resource consumption request, a queue for collecting resource consumption requests that have been locally accepted by the respective proxy server, a local resource consumption counter representing the global resource consumption as seen by the respective proxy server, whereby the local resource consumption counter is updated every time a resource consumption request is accepted by the decision module and the updated value being provided in turn as an input to the decision module, and a synchronization module for synchronizing the global resource consumption counter by interfacing with all other server instances.

BRIEF SUMMARY OF THE FIGURES

Exemplary embodiments of the present invention are explained below with reference to the drawings. In the drawings:

FIG. 1 schematically shows a distributed computing environment,

FIG. 2 schematically shows the structure of a proxy server according to the present invention, and

FIG. 3 schematically shows an embodiment of the present invention using a central resource management system.

DETAILED DESCRIPTION OF THE INVENTION

As noted above, embodiments may provide a method for real-time resource consumption control in a distributed computing environment, wherein this environment comprises a multitude of server instances having access to shared resources, whereby each request for a shared resource issued by a client application is handled by one of the server instances; a global resource consumption counter representing the overall resource consumption of the multitude of server instances at a given time; and a multitude of proxy servers. Each proxy server comprises a receiver module for receiving resource consumption requests issued from a client application, a resource consumption decision module for accepting or rejecting a resource consumption request, a queue for collecting resource consumption requests that have been locally accepted by the respective proxy server, a local resource consumption counter representing the global resource consumption as seen by the respective proxy server, whereby the local resource consumption counter is updated every time a resource consumption request is accepted by the decision module and the updated value being provided in turn as an input to the decision module, and a synchronization module for synchronizing the global resource consumption counter by interfacing with all other server instances.

In a first step, the amount of resource consumption of a request received by the receiver module and accepted by the resource consumption decision module is read from the queue. Subsequently, the local resource consumption counter is synchronized with the global resource consumption counter by adding the amount read in the first step to the global resource consumption counter. Then, the local resource consumption counter is updated with a local copy of the global resource consumption counter value from the second step, and the updated global resource consumption counter value is provided as an input to the resource consumption decision module of the respective proxy server. On every new request read from the queue, the difference between the value of the local copy of the global resource consumption counter value and the global resource consumption counter value at the time of synchronization is determined and the global resource consumption by the decision module is projected based on the difference determined in the preceding step and the time elapsed since the last synchronization of the local copy of the global resource consumption counter and the actual global resource consumption at the time of each synchronization step.

By carrying out the steps of this method, the decision of a decision module, whether a resource consumption request is accepted or rejected, is based on an estimation or projection of the global resource consumption using data which are locally available at each proxy server at the time a decision has to be taken. Thus, there is no need for excessive synchronization between instances.

The solution to the problem also provides a system for real-time resource consumption control in a distributed computing environment. This system comprises a multitude of server instances having access to shared resources, whereby each request for a shared resource issued by a client application is handled by one of the server instances; a global resource consumption counter, representing the overall resource consumption of the multitude of server instances at a given time and a multitude of proxy servers. Each of these proxy servers in turn comprises a receiver module for receiving resource consumption requests issued from a client application, a resource consumption decision module for accepting or rejecting a resource consumption request, a queue for collecting resource consumption requests that have been locally accepted by the respective proxy server, a local resource consumption counter representing the global resource consumption as seen by the respective proxy server, whereby the local resource consumption counter is updated every time a resource consumption request is accepted by the decision module, and the updated value is provided in turn as an input to the decision module. Finally, the system comprises a synchronization module for synchronizing the global resource consumption counter by interfacing with all other server instances.

With such a system, it is possible to determine the resource's availability at each proxy server at the time a decision has to be taken, whether a resource consumption request can be accepted or has to be rejected.

The term “resource” used herein should be interpreted in a rather broad way. “Resource” may refer to any physical or virtual entities of limited availability, e.g., memory, processing capacity, network speed, etc.

In some embodiments, the decision module does not have dependencies on other decision modules. The method is therefore fault tolerant as a failure in one decision module does not have effects to other decision modules. A decision can be taken very fast as all calculating means are contained in the decision module, hence the method applies for real time applications, such as communication applications. Decision taking can scale to infinity by employing an unlimited number of decision modules, as all calculating means are contained in each decision module.

According to a further embodiment, the calculating means are self contained in the decision module. Many different sophisticated decision algorithms can be employed.

In a further embodiment, the algorithm parameters on each decision module are periodically adjusted according to global resource consumption.

A further embodiment has a good fault tolerance: On the event of a failure at one server instance, the load balancer directs new resource consumption requests to other server instances. Further, it has a good scalability: As demand for resource consumption increases, new server instances can be added so that new resource consumption requests are balanced across a larger set of server instances.

A still further embodiment has the ability to easily adapt to the increasing/decreasing demand for resource consumption by dynamically allocating computing power (e.g. new server instances) out of a virtually unlimited pool of physical resources.

FIG. 1 schematically shows a distributed computing environment, consisting of a multitude of server instances S_(x), i.e. (S_(i) -S_(e)) having access to shared resources, whereby each request for a shared resource issued by a consumer or client application CA is handled by one of the server instances S. An optional load balancer LB distributes all requests issued by the client application CA to the multitude of server instances S_(x).

A global resource consumption counter G, representing the overall resource consumption of the multitude of server instances S_(x) at a given time forms part of the distributed computing environment (cf. FIG. 2).

The distributed computing environment further comprises a multitude of proxy servers L_(x), i.e. (L₁-L_(m)) being assigned to the server instances S_(x) (cf. FIG. 3). The structure of these proxy servers is illustrated in FIG. 2. Each proxy server L_(x) comprises:

-   -   a receiver module R for receiving resource consumption requests,         each resource consumption request consisting of the identity of         the requesting entity (e.g. user or group of users) and the         amount of resources that are to be consumed by this particular         request;     -   a resource consumption decision module Dm, which implements a         calculating means whose output is a positive or negative answer         whether to accept a resource consumption request or not. As will         be described later, the decisions taken by the decision module         Dm are strictly based on data which are available locally, i.e.,         at each proxy server, to the system at any given time. The         calculating means may be represented by a respective algorithm;     -   a local resource consumption counter L, representing the global         resource consumption as seen by any single proxy server L_(x).         It is incremented every time a resource consumption request         which arrives at the receiver module R is accepted by the         decision module Dm. In a distributed computing environment with         many independent instances, local resource consumption counter L         represents the sum of the global resource consumption counter G         known to the given local proxy server L_(x) plus the resource         consumption locally accepted by the respective decision module         Dm;     -   a queue Q for storing resource consumption requests that have         been locally accepted by the respective proxy server L_(x;) and     -   a synchronization module S for synchronizing the global resource         consumption counter G of the environment by interfacing with all         other server instances S_(x) , the global resource consumption         counter G representing the overall resource consumption of the         multitude of server instances S.

There are two functions that are running asynchronously and in parallel in every proxy server L_(x). Asynchronously in the present case means that both functions are running independently, i.e., one function does not have to wait for the other function to be finished.

The first function concerns a local decision about whether an incoming request can be accepted or not. The individual steps of this function are, in accordance with the numbers 1 to 6 in FIG. 2, as follows:

-   -   1 a request arrives at the receiver module R;     -   2 a decision is taken by the resource consumption decision         module Dm whether the request is accepted or not, based on a         decision algorithm which will be described later on;     -   3 accepted requests are placed in a queue Q;     -   4 the local resource consumption counter L is updated;     -   5 the consumer or client application CA receives the requested         service, assuming that the request had been accepted before; and     -   6 the updated value of the local resource consumption counter L         is provided as input to the decision module Dm.

The second function concerns a synchronous update of the global resource consumption counter G. The respective steps are, in accordance with the characters A to D in FIG. 2, as follows:

-   -   A the amount of locally accepted resource consumption is read         from the queue Q. This includes the data of all requests that         have been accepted by the decision module Dm of the respective         proxy server S_(x) and are not yet synchronized with the global         resource consumption counter G (see below);     -   B The amount of resources which has been consumed by a given         instance is added to the global resource consumption counter G,         the local queue Q is reset to zero and the new value of the         global resource consumption counter G is read;     -   C the local resource consumption counter L is set to the value         of the recently updated global resource consumption counter G;         and     -   D the new global resource consumption counter value is provided         as input to the decision module Dm.

With respect to the synchronization step B, different embodiments can be envisaged. In one embodiment, there is a central resource management system CRM (cf. FIG. 3) where resources are provisioned and which also maintains the global resource consumption counter G. In its simplest form, the typical client server model is followed, where the local proxy server L_(x) takes the role of the client and the central resource management system CRM takes the role of the server. Client requests are processed by the server one by one, and the response includes the updated global counter.

In another embodiment the synchronization is achieved with the use of messages between the nodes. In this scenario, a messaging system is used. All local proxy servers register for events by other proxy servers. On the reception of the event by the other proxy servers, the global resource consumption counter G, which is locally maintained, gets updated. Additional measures might be needed in this case to ensure that the global resource consumption counter G is consistently updated in all local systems.

In still another embodiment a master/slave arrangement between the instances is used to decide how the master copy of the global resource consumption counter G is maintained. Technically, this is similar to the first embodiment, in the sense that all requests queued to a local proxy server S_(x) are sent to a single server, the difference being that the server receiving the requests and maintaining the global resource consumption counter G is any of the local proxy servers L_(x) with the master role.

The following table further explains the process of the synchronization of the local resource consumption counter L with the global resource consumption counter G by means of an example:

Proxy Global Resource #1 Proxy #2 Proxy #3 consumption Time Event (P1) (P2) (P3) (G) t₀ Q = 0 Q = 0 Q = 0 0 L = 0 L = 0 L = 0 t₁ 10 → P1,  Q = 10 Q = 0 Q = 0 0 L = 10 L = 0 L = 0 t₂ 5 → P2, Q = 10 Q = 5 Q = 0 0 L = 10 L = 5 L = 0 t₃ 7 → P3, Q = 10 Q = 5 Q = 7 0 L = 10 L = 5 L = 7 t₄ 3 → P1, Q = 13 Q = 5 Q = 7 0 L = 13 L = 5 L = 7 t₅ Synch P1 Q = 0 Q = 5 Q = 7 13 L = 13 L = 5 L = 7 t₆ 2 → P1, Q = 2 Q = 5 Q = 7 13 L = 15 L = 5 L = 7 t₇ Synch P2 Q = 2 Q = 0 Q = 7 18 L = 15 L = 18 L = 7 t₈ Synch P3 Q = 2 Q = 0 Q = 0 25 L = 15 L = 18 L = 25 t₉ 5 → P2, Q = 2 Q = 5 Q = 0 25 L = 15 L = 23 L = 25 t₁₀ Synch P1, Q = 0 Q = 5 Q = 0 27 L = 27 L = 23 L = 25

The system in the example comprises three proxy servers (P1 to P3). At time t₀ the system has not processed any requests, i.e., the values for the queue Q, the local resource consumption counter L and the global resource consumption counter G are zero. At time t₁ a request for 10 “resources” is accepted by the decision module Dm of proxy server P1. The queue Q at P1 is incremented by 10, since this amount of resources is not yet synchronized with the global resource consumption counter G. The local resource consumption at P1 is also set to 10, as this is the “global resource consumption counter value” as seen by P1 at this time.

At time t₂ a request for 5 resources is accepted by the decision module Dm of proxy server P2. In a similar manner as before, the queue Q at P2 is incremented by 5, and the local resource consumption at P2 is also set to 5. The same holds true for times t₃ and t₄ with respect to accepted requests by proxy servers P3 and, again, P1.

At time t₅ the local resource consumption counter L of proxy server P1 is synchronized with the global resource consumption counter G. The global resource consumption is set to 13 (same as the local resource consumption at P1), and the queue Q of proxy server P1 is reset.

The next request for 2 resources arriving at time t₆ at P1 increases the queue Q and the local resource consumption value of P1 by 2.

At time t₇, proxy server P2 synchronizes with the global resource consumption counter G. The locally accepted resources at P2 (L=5) are added to the global resource consumption counter G (13) and the new global resource consumption counter value becomes 18. The queue Q at P2 is reset to 0 and the local resource consumption counter is set to the global resource consumption counter value.

In a similar manner, at time t₈ the data of proxy server P3 are synchronized, i.e., another 7 resources are added to the global resource consumption counter G, the value of G now being 25. The queue Q of P3 is reset and L is updated accordingly.

At time t₉ a request for 5 resources is accepted by the decision module of proxy server P2. In a similar manner as before, the queue Q and the local resource consumption counter are incremented by 5 to Q=5 and L=23.

Finally, at time t₁₀, proxy server P1 synchronizes again with the global resource consumption counter G. Its queue Q with 2 resources is added to the global resource consumption counter G, which increases the global resource consumption value from 25 to 27. The local resource consumption counter is synchronized with the global resource consumption usage to be 27.

The decision for accepting or rejecting a resource consumption request takes place locally on each proxy server L_(x) by the resource consumption decision module Dm, taking into account data that are locally available at that specific server.

As already mentioned before, the calculating means present in the decision modules Dm of each proxy server may be represented by a respective algorithm. The following is an example for an algorithm for carrying out the decision by the respective decision module Dm whether to accept or to reject the respective request, thereby using the following inputs:

-   -   a. the provisioned maximum limit for the given resource P     -   b. the local resource consumption counter value L     -   c. the synchronized global resource consumption value G     -   d. the amount of resources to be consumed by the request R

On every new request, at time t_(x), the request is accepted if

P(G_(tx)) + R ≤ P where ${P\left( G_{tx} \right)} = {{\frac{G_{ts} - L_{ts}}{t_{s} - t_{s - 1}}\left( {t_{x} - t_{s}} \right)} + L_{tx}}$

P(G_(tx)) is the projection of global resource consumption G at time t_(x), which is the time when a new request arrives. t_(s) and t_(s−1) are the times where synchronization between the global resource consumption G and its local copy L occurred prior to t_(x) G_(t) and L_(t) are the global and local resource consumption, respectively, at time t.

EXAMPLE

Consider the above example of a file sharing service, where a group of users has purchased a license for 100 GB of storage. The service is provided by N servers. The following events occur (where n/a means not applicable):

Global New Local Local Usage Projected Usage Usage Time Event Usage (L_(t)) (G_(t)) P(G_(t)) Limit Decision L_(t+) t₀ = 0 Synch — 40 n/a — n/a 40 t₁ = 5 Synch 40 50 n/a 100 n/a 50 t₂ = 10  5 50 n/a ${{\frac{50 - 40}{5 - 0}\left( {10 - 5} \right)} + 50} = 60$ 100 Accept 55 t₃ = 20 10 55 n/a ${{\frac{50 - 40}{5 - 0}\left( {20 - 5} \right)} + 55} = 85$ 100 Accept 65 t₄ = 30 Synch 65 90 n/a 100 n/a 90 t₅ = 32 10 90 n/a ${{\frac{90 - 65}{30 - 5}\left( {32 - 30} \right)} + 90} = 92$ 100 Reject 80

At time t₀, the local proxy server P1 synchronizes with the global resource consumption counter G. The local usage is updated to 40.

Five seconds later, at time t₁, the local proxy server synchronizes again and the local resource consumption value is updated to 50.

At time t₂, i.e., ten seconds after t₀, a new request for 5 GB file upload is received. The decision module Dm projects the global resource consumption applying the formula for P(G_(t)) as follows:

${P\left( G_{t_{1}} \right)} = {{{\frac{G_{ts} - L_{ts}}{t_{s} - t_{s - 1}}\left( {t_{x} - t_{s}} \right)} + L_{tx}} = {{{\frac{G_{t\; 1} - L_{t\; 1}}{t_{1} - t_{0}}\left( {t_{2} - t_{1}} \right)} + L_{1 -}} = {{{\frac{50 - 40}{5 - 0}\left( {10 - 5} \right)} + 50} = 60}}}$

The result is that P(G₂)=60, hence the request is accepted and the local resource consumption value is increased to 55.

In a similar manner, another request for 10 GB file upload is accepted at time t₃, and the local resource consumption value is increased to 65.

At time t₄, the proxy server synchronizes again with the global resource consumption counter G. As a result of this synchronization, the local resource consumption value is set equal to the global resource consumption value at time t₄, i.e., to 90.

At time t₅, a new request for a 10 GB file upload is received. The projection of the global usage is now the following:

${P\left( G_{t_{1}} \right)} = {{{\frac{G_{ts} - L_{ts}}{t_{s} - t_{s - 1}}\left( {t_{x} - t_{s}} \right)} + L_{tx}} = {{{\frac{G_{t\; 4} - L_{t\; 4}}{t_{4} - {t\; 1}}\left( {t_{5} - t_{4}} \right)} + L_{5 -}} = {{{\frac{90 - 65}{30 - 5}\left( {32 - 30} \right)} + 90} = 92}}}$

The projected usage is thus calculated at 92 GB. Given the limit of 100 GB and the size of the file upload request, 10, the request is rejected.

In some embodiments more complex projection algorithms can be used. In some other embodiments, new requests are always accepted until the local resource consumption counter exceeds a certain threshold relative to the provisioned limit. 

We claim:
 1. Computer-implemented method for real-time resource consumption control in a distributed computing environment, the environment comprising: a multitude of server instances (S_(x)) having access to shared resources, whereby each request for a shared resource issued by a client application (CA) is handled by one of the server instances (S_(x)); a global resource consumption counter (G), representing the overall resource consumption of the multitude of server instances (S_(x)) at a given time; and a multitude of proxy servers (L_(x)), each proxy server comprising a receiver module (R) for receiving resource consumption requests issued from a client application (CA), a resource consumption decision module (Dm) for accepting or rejecting a resource consumption request, a queue (Q) for collecting resource consumption requests that have been locally accepted by the respective proxy server (L_(x)), a local resource consumption counter (L), representing the global resource consumption as seen by the respective proxy server (L_(x)), said local resource consumption counter (L) being updated every time a resource consumption request is accepted by the decision module (Dm), the updated value being provided in turn as an input to the decision module (Dm), and a synchronization module (S) for synchronizing the global resource consumption counter (G) by interfacing with all other server instances (S_(x)); the method comprising the steps of a) reading, from the queue (Q), the amount of resource consumption of a request received by the receiver module (R) and accepted by the resource consumption decision module (Dm); b) synchronizing the local resource consumption counter (L) with the global resource consumption counter (G) by adding the amount read in step a) to the global resource consumption counter (G); c) updating the local resource consumption counter (L) with a local copy of the global resource consumption counter (G) value from step b); d) providing the updated global resource consumption counter value as an input to the resource consumption decision module (Dm) of the proxy server (L_(x)); e) on every new request read from the queue (Q), determining the difference between the value of the local copy of the global resource consumption counter value and the global resource consumption counter value at the time of synchronization; and f) projecting the global resource consumption by the decision module (Dm) based on the difference determined in step e) and the time elapsed since the last synchronization of the local copy of the global resource consumption counter (G) and the actual global resource consumption at the time of each synchronization step.
 2. Method according to claim 1, characterized in that the resource consumption decision module Dm contains a calculating means for carrying out the decision whether to accept or to reject a new request read from queue Q.
 3. Method according to claim 2, characterized in that the calculating means come to the decision whether to accept or to reject the new request based on the following inputs: a. the provisioned maximum limit for the given resource P, b. the local resource consumption counter value L, c. the synchronized global resource consumption value G, d. the amount of resources to be consumed by the request R; carrying out the following steps: On every new request, at time t_(x), the request is accepted if P(G_(tx)) + R ≤ P where ${P\left( G_{tx} \right)} = {{\frac{G_{ts} - L_{ts}}{t_{s} - t_{s - 1}}\left( {t_{x} - t_{s}} \right)} + {L_{tx}.}}$ P(G_(tx)) is the projection of global resource consumption G at time t_(x), which is the time when a new request arrives. t_(s) and t_(s−1) are the times where synchronization between the global resource consumption G and its local copy L, occurred prior to t_(x) G_(t) and L_(t) are the global and local resource consumption, respectively, at time t.
 4. Method according to claim 1, characterized in that the synchronization step is done by a central resource management server (CRM) maintaining the global resource consumption counter (G).
 5. The method of claim 1, characterized in that a load balancer (LB) distributes all requests issued by the client application (CA) to the multitude of server instances (S_(x)).
 6. The method of claim 1, characterized in that the distributed computing environment is a SaaS environment.
 7. Computer program product, characterized in that it is adapted to carry out the method of claim
 1. 8. Computer readable data carrier, characterized in that a computer program product according to claim 7 is stored thereon.
 9. System for real-time resource consumption control in a distributed environment by carrying out the computer-implemented method according to claim 1, the system comprising: a multitude of server instances (S_(x)) having access to shared resources, whereby each request for a shared resource issued by a client application (CA) is handled by one of the server instances (S_(x)); a global resource consumption counter (G), representing the overall resource consumption of the multitude of server instances (S_(x)) at a given time; and a multitude of proxy servers (L_(x)), each proxy server comprising a receiver module (R) for receiving resource consumption requests issued from a client application (CA), a resource consumption decision module (Dm) for accepting or rejecting a resource consumption request, a queue (Q) for collecting resource consumption requests that have been locally accepted by the respective proxy server (L_(x)), a local resource consumption counter (L), representing the global resource consumption as seen by the respective proxy server (L_(x)), said local resource consumption counter (L) being updated every time a resource consumption request is accepted by the decision module (Dm), the updated value being provided in turn as an input to the decision module (Dm), and a synchronization module (S) for synchronizing the global resource consumption counter (G) by interfacing with all other server instances (S). 